tests/unsubmitted_forms/cleanup_unsubmitted_forms.ts (2)

51-57: Improve type safety for transaction array.

Using any[] loses type safety. Consider using the proper Prisma type for transaction operations.

♻️ Suggested improvement

-      const deleteOperations: any[] = [
+      const deleteOperations: Prisma.PrismaPromise<unknown>[] = [

You'll need to import Prisma from @prisma/client:

-import type { JobScheduleQueue } from "@prisma/client";
+import type { JobScheduleQueue, Prisma } from "@prisma/client";

---

43-89: Consider resilient error handling for partial failures.

If a transaction fails for one token (e.g., due to a constraint violation or transient error), the job immediately fails and remaining tokens are not processed. This could leave the cleanup incomplete and require manual intervention.

Consider wrapping individual token processing in a try-catch to continue with remaining tokens, logging failures, and summarizing at the end:

♻️ Suggested approach

+    const failures: Array<{ token: string; error: unknown }> = [];
+
     for (const token of expiredTokens) {
+      try {
         const relationship = await prisma.relationship.findFirst({
           // ... existing code ...
         });

         // ... build deleteOperations ...

         await prisma.$transaction(deleteOperations);
+      } catch (tokenError) {
+        console.error(`Failed to cleanup token ${token.token}:`, tokenError);
+        failures.push({ token: token.token, error: tokenError });
+      }
     }

-    await update_job_status(job.id, "completed");
+    if (failures.length > 0) {
+      console.error(`Cleanup completed with ${failures.length} failures`);
+      await update_job_status(job.id, "failed");
+    } else {
+      await update_job_status(job.id, "completed");
+    }
   } catch (error) {
     console.error("Error cleaning up unsubmitted forms:", error);
     await update_job_status(job.id, "failed");
     throw error;
   }

tests/unsubmitted_forms/cleanup_unsubmitted_forms.ts (1)

47-55: De-duplicate ID lists before IN filters.

This reduces query size and avoids unnecessary parameter bloat for large batches.

♻️ Suggested diff

-    const tokenStrings = expiredTokens.map((t) => t.token);
-    const entityIds = expiredTokens
-      .map((t) => t.entityId)
-      .filter((id): id is string => id !== null && id !== undefined);
-    const productIds = expiredTokens
-      .map((t) => t.productId)
-      .filter((id): id is string => id !== null && id !== undefined);
+    const tokenStrings = [...new Set(expiredTokens.map((t) => t.token))];
+    const entityIds = [
+      ...new Set(
+        expiredTokens
+          .map((t) => t.entityId)
+          .filter((id): id is string => id !== null && id !== undefined)
+      ),
+    ];
+    const productIds = [
+      ...new Set(
+        expiredTokens
+          .map((t) => t.productId)
+          .filter((id): id is string => id !== null && id !== undefined)
+      ),
+    ];

tests/unsubmitted_forms/cleanup_unsubmitted_forms.ts (1)

67-87: Consider adding guards for empty arrays to avoid unnecessary queries.

When all tokens have null entityId or productId, the corresponding arrays will be empty. While Prisma's { in: [] } safely matches nothing, executing these queries adds unnecessary database round-trips.

♻️ Proposed optimization to skip queries for empty arrays

     // batch delete in a single transaction - order matters for FK constraints
-    await prisma.$transaction([
-      // delete relationships tied to these products that are still "new" (unsubmitted)
-      prisma.relationship.deleteMany({
+    const operations = [];
+
+    // delete relationships tied to these products that are still "new" (unsubmitted)
+    if (productIds.length > 0) {
+      operations.push(prisma.relationship.deleteMany({
         where: {
           product_id: { in: productIds },
           status: "new",
         },
-      }),
-      // delete corpus items before entities (they reference entity_id)
-      prisma.new_corpus.deleteMany({
-        where: { entity_id: { in: entityIds } },
-      }),
-      // delete the entities
-      prisma.entity.deleteMany({
-        where: { id: { in: entityIds } },
-      }),
-      // finally delete the tokens
-      prisma.publicFormsTokens.deleteMany({
-        where: { token: { in: tokenStrings } },
-      }),
-    ]);
+      }));
+    }
+
+    // delete corpus items before entities (they reference entity_id)
+    if (entityIds.length > 0) {
+      operations.push(prisma.new_corpus.deleteMany({
+        where: { entity_id: { in: entityIds } },
+      }));
+      operations.push(prisma.entity.deleteMany({
+        where: { id: { in: entityIds } },
+      }));
+    }
+
+    // always delete the tokens
+    operations.push(prisma.publicFormsTokens.deleteMany({
+      where: { token: { in: tokenStrings } },
+    }));
+
+    await prisma.$transaction(operations);